﻿using System;
using System.Collections.Generic;
using System.Linq.Expressions;
using System.Reflection;

namespace MyBasicLib.Reflection.FastReflection.Lambda
{
    public class MethodInvoker : IMethodInvoker
    {
        private readonly Func<object, object[], object> m_invoker;

        public MethodInvoker(MethodInfo methodInfo)
        {
            MethodInfo = methodInfo;
            m_invoker = CreateInvokeDelegate(methodInfo);
        }

        public MethodInfo MethodInfo { get; private set; }

        #region IMethodInvoker Members

        object IMethodInvoker.Invoke(object instance, params object[] parameters)
        {
            return Invoke(instance, parameters);
        }

        #endregion

        public object Invoke(object instance, params object[] parameters)
        {
            return m_invoker(instance, parameters);
        }

        private static Func<object, object[], object> CreateInvokeDelegate(MethodInfo methodInfo)
        {
            // Target: ((TInstance)instance).Method((T0)parameters[0], (T1)parameters[1], ...)

            // parameters to execute
            ParameterExpression instanceParameter = Expression.Parameter(typeof (object), "instance");
            ParameterExpression parametersParameter = Expression.Parameter(typeof (object[]), "parameters");

            // build parameter list
            var parameterExpressions = new List<Expression>();
            ParameterInfo[] paramInfos = methodInfo.GetParameters();
            for (int i = 0; i < paramInfos.Length; i++)
            {
                // (Ti)parameters[i]
                BinaryExpression valueObj = Expression.ArrayIndex(
                    parametersParameter, Expression.Constant(i));
                UnaryExpression valueCast = Expression.Convert(
                    valueObj, paramInfos[i].ParameterType);

                parameterExpressions.Add(valueCast);
            }

            // non-instance for static method, or ((TInstance)instance)
            UnaryExpression instanceCast = methodInfo.IsStatic
                                               ? null
                                               : Expression.Convert(instanceParameter, methodInfo.ReflectedType);

            // static invoke or ((TInstance)instance).Method
            MethodCallExpression methodCall = Expression.Call(instanceCast, methodInfo, parameterExpressions);

            // ((TInstance)instance).Method((T0)parameters[0], (T1)parameters[1], ...)
            if (methodCall.Type == typeof (void))
            {
                Expression<Action<object, object[]>> lambda = Expression.Lambda<Action<object, object[]>>(
                    methodCall, instanceParameter, parametersParameter);

                Action<object, object[]> execute = lambda.Compile();
                return (instance, parameters) =>
                           {
                               execute(instance, parameters);
                               return null;
                           };
            }
            else
            {
                UnaryExpression castMethodCall = Expression.Convert(methodCall, typeof (object));
                Expression<Func<object, object[], object>> lambda = Expression.Lambda<Func<object, object[], object>>(
                    castMethodCall, instanceParameter, parametersParameter);

                return lambda.Compile();
            }
        }
    }
}